﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace YasharEl.Infrastructure.SoftwareModel.SOA
{
    /// <summary>
    /// Activity Services implement the business-level capabilities 
    /// or some other action-centric business-logic elements ("building blocks") 
    /// that are unique to a particular application. 
    /// The main difference between Activity Services and Capability Services 
    /// is the scope in which they are used. 
    /// While Capability Services are an organizational resource,
    /// Activity Services are used in a much smaller scope, 
    /// such as a single composite application or a single solution (comprising of several applications). 
    /// Over the course of time and with enough reuse across the organization, 
    /// an Activity Service may evolve into a Capability Service.
    /// 
    /// Activity Services are typically created to facilitate the decomposition of a complicated process 
    /// or to enable reuse of a particular unit-of-functionality in several places 
    /// in a particular Process Service or even across different Process Services in the application. 
    /// The forces driving the creation of Activity Services can stem from a variety of sources, 
    /// such as organizational forces, security requirements, regulatory requirements, and so forth. 
    /// 
    /// An example of an Activity Service that is created in a decomposition scenario 
    /// is a vacation eligibility confirmation service which, 
    /// due to security requirements, separates a particular part of a vacation authorization application's behavior 
    /// in order for that part to run behind the HR department's firewall 
    /// and access the HR department's protected databases 
    /// to validate vacation eligibility. 
    /// An example of an Activity Service used for sharing functionality 
    /// would be a blacklist service that provides information on a customer's blacklist status, 
    /// so that this information can be used by several Process Services within a solution.
    /// 
    /// Like Capability Services, Activity Services expose a service interface specific to the capability they implement. 
    /// It is possible for an Activity Service to wrap an existing unit of functionality, 
    /// especially in transition cases where an existing system 
    /// with existing implemented functionality is being updated to 
    /// or included in an SOA-based solution.
    /// 
    /// Like Capability Services, Activity Services typically do not manage application 
    /// state directly; if they do manage state, that state is transient and exists for a period of time 
    /// that is shorter than the life span of the business process 
    /// that the service partakes in. 
    /// However, because of their slightly larger granularity—and because, 
    /// in some cases, Activity Services are used to wrap an existing system—it 
    /// is more likely that an Activity Service will manage and encapsulate application state.
    /// 
    /// Users of Activity Services may require a permission to be configured for them 
    /// in order to use the service, be it at the application, user, or the application-user scope. 
    /// As in the case of Capability Services, access to an Activity Service is typically granted 
    /// at the application level and managed for each user 
    /// by the Process Services that are using the Activity Service.
    /// 
    /// Activity Services have the same characteristics for error compensation 
    /// and transaction support as Capability Services. 
    /// Activity Services are typically developed and managed in-house, 
    /// and may be implemented using imperative code or a declarative workflow. 
    /// As in the case of a Capability Service, if implemented as a workflow an Activity Service 
    /// may be modeled as a short-running business-activity.
    /// 
    /// Activity Services are typically used by a single application 
    /// or solution and, therefore, are typically managed individually 
    /// (for example, at a departmental level). 
    /// If an Activity Service evolves into a Capability Service, 
    /// the management of the service typically transitions to a central management facility.
    /// </summary>
    public interface IActivityService : IApplicationService
    {
    }
}
